carvalhoviniciusluiz / restify-devise

import path from 'path'

import restify from 'restify'

import logger from 'winston'

import * as errors from 'restify-errors'

import chalk from 'chalk'

import config from '../config'

import router from './router'

// import favicon from 'serve-favicon'

import compression from 'compression'

import helmet from 'helmet'

import validator from 'restify-joi-middleware'

import passport from './helpers/passport'

import restifyRender from 'restify-render-middleware'

import { pug } from 'consolidate'

import acceptLanguage from 'accept-language'

import i18n, { languages } from './helpers/i18n'

import socketio from 'socket.io'

import channels from './channels'

import corsMiddleware from 'restify-cors-middleware'

// set supported languages

acceptLanguage.languages(languages)

const server = restify.createServer({

  name: 'Restify Devise',

  version: '1.0.0',

  // https://github.com/restify/node-restify/issues/1219#issuecomment-328499227

  // https://github.com/makeomatic/restify-formatter-jsonapi/issues/2#issuecomment-307285452

  ignoreTrailingSlash: true

})

// set websocket app

const io = socketio.listen(server.server)

channels(io)

server.use(restify.plugins.acceptParser(server.acceptable))

server.use(restify.plugins.queryParser())

server.use(restify.plugins.bodyParser())

server.use(restify.plugins.fullResponse())

server.use(restify.plugins.gzipResponse())

// CORS middleware

const cors = corsMiddleware({

  preflightMaxAge: 5,

  allowHeaders: ['Authorization']

})

server.pre(cors.preflight)

server.use(cors.actual)

// https://www.npmjs.com/package/compression#filter-1

server.use(compression({

  filter (request, response) {

    if (request.headers['x-no-compression']) {

      logger.warn('server', 'X-No-Compresseion')

      // don't compress responses with this request header

      return false

    }

    // fallback to standard filter function

    return compression.filter(request, response)

  }

}))

// https://www.npmjs.com/package/helmet#how-it-works

server.use(helmet())

server.use(helmet.noCache())

server.use(helmet.referrerPolicy())

// joi validation middleware for restify

server.use(validator({

  joiOptions: {

    allowUnknown: false

  },

  errorTransformer: (validationInput, joiError) => {

    const { type, context } = joiError.details[0]

    const retError = new errors.BadRequestError()

    retError.body.message = {

      warn: `'${i18n.t(context.key)}' ${i18n.t(type, context)}`,

      context: joiError.details[0].context

    }

    return retError

  }

}))

// i18n middleware for restify

server.use(i18n.handler())

// add res.render()

server.use(restifyRender({

  engine: pug,

  dir: path.join(__dirname, 'views')

}))

server.pre((request, response, next) => {

  logger.info('[server]', request.method, request.url)

  next()

})

server.pre((req, res, next) => {

  const headerValue = req.headers['accept-language']

  if (headerValue) {

    i18n.changeLanguage(acceptLanguage.get(headerValue))

  }

  next()

})

passport.initialize(server)

// asset routing added

server.get('/assets/*', restify.plugins.serveStatic({

  directory: __dirname

  // default: 'style.css'

}))

// set routes app

router(server)

// TODO

// http://restify.com/docs/plugins-api/#auditlogger

// https://github.com/trentm/node-bunyan-winston/blob/master/restify-winston.js#L18-L80

// Restify servers emit all the events from the node http.Server and has several other events you want to listen on.

// http://nodejs.org/docs/latest/api/http.html#http_class_http_server

// When a client request is sent for a URL that does not exist, restify will emit this event.

// Note that restify checks for listeners on this event, and if there are none, responds with a default 404 handler.

// It is expected that if you listen for this event, you respond to the client.

server.on('NotFound', (request, response, error, next) => {

  const url = (request.isSecure())

    ? 'https'

    : 'http' + '://' + request.headers.host + request.url

  logger.warn('[server]', `Route ${chalk.cyan(url)} not found`)

  return next(new errors.NotFoundError())

})

// When a client request is sent for a URL that does exist, but you have not registered a route for that HTTP verb,

// restify will emit this event. Note that restify checks for listeners on this event, and if there are none,

// responds with a default 405 handler. It is expected that if you listen for this event, you respond to the client.

// server.on('MethodNotAllowed', (request, response, next) => {})

// When a client request is sent for a route that exists, but does not match the version(s) on those routes,

// restify will emit this event. Note that restify checks for listeners on this event, and if there are none,

// responds with a default 400 handler. It is expected that if you listen for this event, you respond to the client.

// server.on('VersionNotAllowed', (request, response, next) => {})

// When a client request is sent for a route that exist, but has a content-type mismatch,

// restify will emit this event. Note that restify checks for listeners on this event, and if there are none,

// responds with a default 415 handler. It is expected that if you listen for this event, you respond to the client.

// server.on('UnsupportedMediaType', (request, response, next) => {})

// Emitted after a route has finished all the handlers you registered.

// You can use this to write audit logs, etc. The route parameter will be the Route object that ran.

// server.on('after', (request, response, route, error) => {})

// Emitted when some handler throws an uncaughtException somewhere in the chain.

// The default behavior is to just call res.send(error), and let the built-ins in restify handle transforming,

// but you can override to whatever you want here.

server.on('uncaughtException', (request, response, route, error) => {

  logger.error('[server]', error.stack)

  response.send(error)

})

// error handler

server.on('error', (error) => {

  onError(error)

})

const port = normalizePort(config.server.port)

/**

  * Normalize a port into a number, string, or false.

  */

/**

  * Event listener for HTTP server "error" event.

  */

function onError (err) {

  if (err.syscall !== 'listen') {

    throw err

  }

  const bind = typeof port === 'string'

    ? 'Pipe ' + port

    : 'Port ' + port

  // handle specific listen errors with friendly messages

  /* eslint-disable no-unreachable */

    case 'EACCES':

      err.message = `${bind} requires elevated privileges`

      logger.error('[server]', err.message)

      break

    // lsof -i tcp:8088

    // kill -9 <PID>

    case 'EADDRINUSE':

      err.message = `${bind} is already in use`

      logger.error('[server]', err.message)

      break

  }

  throw err

}

module.exports = server